2
          
          require 'mail'
        
      
        

          2
          
          require 'action_mailer/collector'
        
      
        

          2
          
          require 'active_support/core_ext/string/inflections'
        
      
        

          2
          
          require 'active_support/core_ext/hash/except'
        
      
        

          2
          
          require 'active_support/core_ext/module/anonymous'
        
      
        

          
          
          
        
      
        

          2
          
          require 'action_mailer/log_subscriber'
        
      
        

          
          
          
        
      
        

          2
          
          module ActionMailer
        
      
        

          
          
            # Action Mailer allows you to send email from your application using a mailer model and views.
        
      
        

          
          
            #
        
      
        

          
          
            # = Mailer Models
        
      
        

          
          
            #
        
      
        

          
          
            # To use Action Mailer, you need to create a mailer model.
        
      
        

          
          
            #
        
      
        

          
          
            #   $ rails generate mailer Notifier
        
      
        

          
          
            #
        
      
        

          
          
            # The generated model inherits from <tt>ApplicationMailer</tt> which in turn
        
      
        

          
          
            # inherits from <tt>ActionMailer::Base</tt>. A mailer model defines methods
        
      
        

          
          
            # used to generate an email message. In these methods, you can setup variables to be used in
        
      
        

          
          
            # the mailer views, options on the mail itself such as the <tt>:from</tt> address, and attachments.
        
      
        

          
          
            #
        
      
        

          
          
            #   class ApplicationMailer < ActionMailer::Base
        
      
        

          
          
            #     default from: 'from@exmaple.com'
        
      
        

          
          
            #     layout 'mailer'
        
      
        

          
          
            #   end
        
      
        

          
          
            #
        
      
        

          
          
            #   class Notifier < ApplicationMailer
        
      
        

          
          
            #     default from: 'no-reply@example.com',
        
      
        

          
          
            #             return_path: 'system@example.com'
        
      
        

          
          
            #
        
      
        

          
          
            #     def welcome(recipient)
        
      
        

          
          
            #       @account = recipient
        
      
        

          
          
            #       mail(to: recipient.email_address_with_name,
        
      
        

          
          
            #            bcc: ["bcc@example.com", "Order Watcher <watcher@example.com>"])
        
      
        

          
          
            #     end
        
      
        

          
          
            #   end
        
      
        

          
          
            #
        
      
        

          
          
            # Within the mailer method, you have access to the following methods:
        
      
        

          
          
            #
        
      
        

          
          
            # * <tt>attachments[]=</tt> - Allows you to add attachments to your email in an intuitive
        
      
        

          
          
            #   manner; <tt>attachments['filename.png'] = File.read('path/to/filename.png')</tt>
        
      
        

          
          
            #
        
      
        

          
          
            # * <tt>attachments.inline[]=</tt> - Allows you to add an inline attachment to your email
        
      
        

          
          
            #   in the same manner as <tt>attachments[]=</tt>
        
      
        

          
          
            #
        
      
        

          
          
            # * <tt>headers[]=</tt> - Allows you to specify any header field in your email such
        
      
        

          
          
            #   as <tt>headers['X-No-Spam'] = 'True'</tt>. Note that declaring a header multiple times
        
      
        

          
          
            #   will add many fields of the same name. Read #headers doc for more information.
        
      
        

          
          
            #
        
      
        

          
          
            # * <tt>headers(hash)</tt> - Allows you to specify multiple headers in your email such
        
      
        

          
          
            #   as <tt>headers({'X-No-Spam' => 'True', 'In-Reply-To' => '1234@message.id'})</tt>
        
      
        

          
          
            #
        
      
        

          
          
            # * <tt>mail</tt> - Allows you to specify email to be sent.
        
      
        

          
          
            #
        
      
        

          
          
            # The hash passed to the mail method allows you to specify any header that a <tt>Mail::Message</tt>
        
      
        

          
          
            # will accept (any valid email header including optional fields).
        
      
        

          
          
            #
        
      
        

          
          
            # The mail method, if not passed a block, will inspect your views and send all the views with
        
      
        

          
          
            # the same name as the method, so the above action would send the +welcome.text.erb+ view
        
      
        

          
          
            # file as well as the +welcome.html.erb+ view file in a +multipart/alternative+ email.
        
      
        

          
          
            #
        
      
        

          
          
            # If you want to explicitly render only certain templates, pass a block:
        
      
        

          
          
            #
        
      
        

          
          
            #   mail(to: user.email) do |format|
        
      
        

          
          
            #     format.text
        
      
        

          
          
            #     format.html
        
      
        

          
          
            #   end
        
      
        

          
          
            #
        
      
        

          
          
            # The block syntax is also useful in providing information specific to a part:
        
      
        

          
          
            #
        
      
        

          
          
            #   mail(to: user.email) do |format|
        
      
        

          
          
            #     format.text(content_transfer_encoding: "base64")
        
      
        

          
          
            #     format.html
        
      
        

          
          
            #   end
        
      
        

          
          
            #
        
      
        

          
          
            # Or even to render a special view:
        
      
        

          
          
            #
        
      
        

          
          
            #   mail(to: user.email) do |format|
        
      
        

          
          
            #     format.text
        
      
        

          
          
            #     format.html { render "some_other_template" }
        
      
        

          
          
            #   end
        
      
        

          
          
            #
        
      
        

          
          
            # = Mailer views
        
      
        

          
          
            #
        
      
        

          
          
            # Like Action Controller, each mailer class has a corresponding view directory in which each
        
      
        

          
          
            # method of the class looks for a template with its name.
        
      
        

          
          
            #
        
      
        

          
          
            # To define a template to be used with a mailing, create an <tt>.erb</tt> file with the same
        
      
        

          
          
            # name as the method in your mailer model. For example, in the mailer defined above, the template at
        
      
        

          
          
            # <tt>app/views/notifier/welcome.text.erb</tt> would be used to generate the email.
        
      
        

          
          
            #
        
      
        

          
          
            # Variables defined in the methods of your mailer model are accessible as instance variables in their
        
      
        

          
          
            # corresponding view.
        
      
        

          
          
            #
        
      
        

          
          
            # Emails by default are sent in plain text, so a sample view for our model example might look like this:
        
      
        

          
          
            #
        
      
        

          
          
            #   Hi <%= @account.name %>,
        
      
        

          
          
            #   Thanks for joining our service! Please check back often.
        
      
        

          
          
            #
        
      
        

          
          
            # You can even use Action View helpers in these views. For example:
        
      
        

          
          
            #
        
      
        

          
          
            #   You got a new note!
        
      
        

          
          
            #   <%= truncate(@note.body, length: 25) %>
        
      
        

          
          
            #
        
      
        

          
          
            # If you need to access the subject, from or the recipients in the view, you can do that through message object:
        
      
        

          
          
            #
        
      
        

          
          
            #   You got a new note from <%= message.from %>!
        
      
        

          
          
            #   <%= truncate(@note.body, length: 25) %>
        
      
        

          
          
            #
        
      
        

          
          
            #
        
      
        

          
          
            # = Generating URLs
        
      
        

          
          
            #
        
      
        

          
          
            # URLs can be generated in mailer views using <tt>url_for</tt> or named routes. Unlike controllers from
        
      
        

          
          
            # Action Pack, the mailer instance doesn't have any context about the incoming request, so you'll need
        
      
        

          
          
            # to provide all of the details needed to generate a URL.
        
      
        

          
          
            #
        
      
        

          
          
            # When using <tt>url_for</tt> you'll need to provide the <tt>:host</tt>, <tt>:controller</tt>, and <tt>:action</tt>:
        
      
        

          
          
            #
        
      
        

          
          
            #   <%= url_for(host: "example.com", controller: "welcome", action: "greeting") %>
        
      
        

          
          
            #
        
      
        

          
          
            # When using named routes you only need to supply the <tt>:host</tt>:
        
      
        

          
          
            #
        
      
        

          
          
            #   <%= users_url(host: "example.com") %>
        
      
        

          
          
            #
        
      
        

          
          
            # You should use the <tt>named_route_url</tt> style (which generates absolute URLs) and avoid using the
        
      
        

          
          
            # <tt>named_route_path</tt> style (which generates relative URLs), since clients reading the mail will
        
      
        

          
          
            # have no concept of a current URL from which to determine a relative path.
        
      
        

          
          
            #
        
      
        

          
          
            # It is also possible to set a default host that will be used in all mailers by setting the <tt>:host</tt>
        
      
        

          
          
            # option as a configuration option in <tt>config/application.rb</tt>:
        
      
        

          
          
            #
        
      
        

          
          
            #   config.action_mailer.default_url_options = { host: "example.com" }
        
      
        

          
          
            #
        
      
        

          
          
            # When you decide to set a default <tt>:host</tt> for your mailers, then you need to make sure to use the
        
      
        

          
          
            # <tt>only_path: false</tt> option when using <tt>url_for</tt>. Since the <tt>url_for</tt> view helper
        
      
        

          
          
            # will generate relative URLs by default when a <tt>:host</tt> option isn't explicitly provided, passing
        
      
        

          
          
            # <tt>only_path: false</tt> will ensure that absolute URLs are generated.
        
      
        

          
          
            #
        
      
        

          
          
            # = Sending mail
        
      
        

          
          
            #
        
      
        

          
          
            # Once a mailer action and template are defined, you can deliver your message or create it and save it
        
      
        

          
          
            # for delivery later:
        
      
        

          
          
            #
        
      
        

          
          
            #   Notifier.welcome(User.first).deliver_now # sends the email
        
      
        

          
          
            #   mail = Notifier.welcome(User.first)      # => an ActionMailer::MessageDelivery object
        
      
        

          
          
            #   mail.deliver_now                    # sends the email
        
      
        

          
          
            #
        
      
        

          
          
            # The <tt>ActionMailer::MessageDelivery</tt> class is a wrapper around a <tt>Mail::Message</tt> object. If
        
      
        

          
          
            # you want direct access to the <tt>Mail::Message</tt> object you can call the <tt>message</tt> method on
        
      
        

          
          
            # the <tt>ActionMailer::MessageDelivery</tt> object.
        
      
        

          
          
            #
        
      
        

          
          
            #   Notifier.welcome(User.first).message     # => a Mail::Message object
        
      
        

          
          
            #
        
      
        

          
          
            # Action Mailer is nicely integrated with Active Job so you can send emails in the background (example: outside
        
      
        

          
          
            # of the request-response cycle, so the user doesn't have to wait on it):
        
      
        

          
          
            #
        
      
        

          
          
            #   Notifier.welcome(User.first).deliver_later # enqueue the email sending to Active Job
        
      
        

          
          
            #
        
      
        

          
          
            # You never instantiate your mailer class. Rather, you just call the method you defined on the class itself.
        
      
        

          
          
            #
        
      
        

          
          
            # = Multipart Emails
        
      
        

          
          
            #
        
      
        

          
          
            # Multipart messages can also be used implicitly because Action Mailer will automatically detect and use
        
      
        

          
          
            # multipart templates, where each template is named after the name of the action, followed by the content
        
      
        

          
          
            # type. Each such detected template will be added as a separate part to the message.
        
      
        

          
          
            #
        
      
        

          
          
            # For example, if the following templates exist:
        
      
        

          
          
            # * signup_notification.text.erb
        
      
        

          
          
            # * signup_notification.html.erb
        
      
        

          
          
            # * signup_notification.xml.builder
        
      
        

          
          
            # * signup_notification.yml.erb
        
      
        

          
          
            #
        
      
        

          
          
            # Each would be rendered and added as a separate part to the message, with the corresponding content
        
      
        

          
          
            # type. The content type for the entire message is automatically set to <tt>multipart/alternative</tt>,
        
      
        

          
          
            # which indicates that the email contains multiple different representations of the same email
        
      
        

          
          
            # body. The same instance variables defined in the action are passed to all email templates.
        
      
        

          
          
            #
        
      
        

          
          
            # Implicit template rendering is not performed if any attachments or parts have been added to the email.
        
      
        

          
          
            # This means that you'll have to manually add each part to the email and set the content type of the email
        
      
        

          
          
            # to <tt>multipart/alternative</tt>.
        
      
        

          
          
            #
        
      
        

          
          
            # = Attachments
        
      
        

          
          
            #
        
      
        

          
          
            # Sending attachment in emails is easy:
        
      
        

          
          
            #
        
      
        

          
          
            #   class Notifier < ApplicationMailer
        
      
        

          
          
            #     def welcome(recipient)
        
      
        

          
          
            #       attachments['free_book.pdf'] = File.read('path/to/file.pdf')
        
      
        

          
          
            #       mail(to: recipient, subject: "New account information")
        
      
        

          
          
            #     end
        
      
        

          
          
            #   end
        
      
        

          
          
            #
        
      
        

          
          
            # Which will (if it had both a <tt>welcome.text.erb</tt> and <tt>welcome.html.erb</tt>
        
      
        

          
          
            # template in the view directory), send a complete <tt>multipart/mixed</tt> email with two parts,
        
      
        

          
          
            # the first part being a <tt>multipart/alternative</tt> with the text and HTML email parts inside,
        
      
        

          
          
            # and the second being a <tt>application/pdf</tt> with a Base64 encoded copy of the file.pdf book
        
      
        

          
          
            # with the filename +free_book.pdf+.
        
      
        

          
          
            #
        
      
        

          
          
            # If you need to send attachments with no content, you need to create an empty view for it,
        
      
        

          
          
            # or add an empty body parameter like this:
        
      
        

          
          
            #
        
      
        

          
          
            #     class Notifier < ApplicationMailer
        
      
        

          
          
            #       def welcome(recipient)
        
      
        

          
          
            #         attachments['free_book.pdf'] = File.read('path/to/file.pdf')
        
      
        

          
          
            #         mail(to: recipient, subject: "New account information", body: "")
        
      
        

          
          
            #       end
        
      
        

          
          
            #     end
        
      
        

          
          
            #
        
      
        

          
          
            # = Inline Attachments
        
      
        

          
          
            #
        
      
        

          
          
            # You can also specify that a file should be displayed inline with other HTML. This is useful
        
      
        

          
          
            # if you want to display a corporate logo or a photo.
        
      
        

          
          
            #
        
      
        

          
          
            #   class Notifier < ApplicationMailer
        
      
        

          
          
            #     def welcome(recipient)
        
      
        

          
          
            #       attachments.inline['photo.png'] = File.read('path/to/photo.png')
        
      
        

          
          
            #       mail(to: recipient, subject: "Here is what we look like")
        
      
        

          
          
            #     end
        
      
        

          
          
            #   end
        
      
        

          
          
            #
        
      
        

          
          
            # And then to reference the image in the view, you create a <tt>welcome.html.erb</tt> file and
        
      
        

          
          
            # make a call to +image_tag+ passing in the attachment you want to display and then call
        
      
        

          
          
            # +url+ on the attachment to get the relative content id path for the image source:
        
      
        

          
          
            #
        
      
        

          
          
            #   <h1>Please Don't Cringe</h1>
        
      
        

          
          
            #
        
      
        

          
          
            #   <%= image_tag attachments['photo.png'].url -%>
        
      
        

          
          
            #
        
      
        

          
          
            # As we are using Action View's +image_tag+ method, you can pass in any other options you want:
        
      
        

          
          
            #
        
      
        

          
          
            #   <h1>Please Don't Cringe</h1>
        
      
        

          
          
            #
        
      
        

          
          
            #   <%= image_tag attachments['photo.png'].url, alt: 'Our Photo', class: 'photo' -%>
        
      
        

          
          
            #
        
      
        

          
          
            # = Observing and Intercepting Mails
        
      
        

          
          
            #
        
      
        

          
          
            # Action Mailer provides hooks into the Mail observer and interceptor methods. These allow you to
        
      
        

          
          
            # register classes that are called during the mail delivery life cycle.
        
      
        

          
          
            #
        
      
        

          
          
            # An observer class must implement the <tt>:delivered_email(message)</tt> method which will be
        
      
        

          
          
            # called once for every email sent after the email has been sent.
        
      
        

          
          
            #
        
      
        

          
          
            # An interceptor class must implement the <tt>:delivering_email(message)</tt> method which will be
        
      
        

          
          
            # called before the email is sent, allowing you to make modifications to the email before it hits
        
      
        

          
          
            # the delivery agents. Your class should make any needed modifications directly to the passed
        
      
        

          
          
            # in <tt>Mail::Message</tt> instance.
        
      
        

          
          
            #
        
      
        

          
          
            # = Default Hash
        
      
        

          
          
            #
        
      
        

          
          
            # Action Mailer provides some intelligent defaults for your emails, these are usually specified in a
        
      
        

          
          
            # default method inside the class definition:
        
      
        

          
          
            #
        
      
        

          
          
            #   class Notifier < ApplicationMailer
        
      
        

          
          
            #     default sender: 'system@example.com'
        
      
        

          
          
            #   end
        
      
        

          
          
            #
        
      
        

          
          
            # You can pass in any header value that a <tt>Mail::Message</tt> accepts. Out of the box,
        
      
        

          
          
            # <tt>ActionMailer::Base</tt> sets the following:
        
      
        

          
          
            #
        
      
        

          
          
            # * <tt>mime_version: "1.0"</tt>
        
      
        

          
          
            # * <tt>charset:      "UTF-8",</tt>
        
      
        

          
          
            # * <tt>content_type: "text/plain",</tt>
        
      
        

          
          
            # * <tt>parts_order:  [ "text/plain", "text/enriched", "text/html" ]</tt>
        
      
        

          
          
            #
        
      
        

          
          
            # <tt>parts_order</tt> and <tt>charset</tt> are not actually valid <tt>Mail::Message</tt> header fields,
        
      
        

          
          
            # but Action Mailer translates them appropriately and sets the correct values.
        
      
        

          
          
            #
        
      
        

          
          
            # As you can pass in any header, you need to either quote the header as a string, or pass it in as
        
      
        

          
          
            # an underscored symbol, so the following will work:
        
      
        

          
          
            #
        
      
        

          
          
            #   class Notifier < ApplicationMailer
        
      
        

          
          
            #     default 'Content-Transfer-Encoding' => '7bit',
        
      
        

          
          
            #             content_description: 'This is a description'
        
      
        

          
          
            #   end
        
      
        

          
          
            #
        
      
        

          
          
            # Finally, Action Mailer also supports passing <tt>Proc</tt> objects into the default hash, so you
        
      
        

          
          
            # can define methods that evaluate as the message is being generated:
        
      
        

          
          
            #
        
      
        

          
          
            #   class Notifier < ApplicationMailer
        
      
        

          
          
            #     default 'X-Special-Header' => Proc.new { my_method }
        
      
        

          
          
            #
        
      
        

          
          
            #     private
        
      
        

          
          
            #
        
      
        

          
          
            #       def my_method
        
      
        

          
          
            #         'some complex call'
        
      
        

          
          
            #       end
        
      
        

          
          
            #   end
        
      
        

          
          
            #
        
      
        

          
          
            # Note that the proc is evaluated right at the start of the mail message generation, so if you
        
      
        

          
          
            # set something in the defaults using a proc, and then set the same thing inside of your
        
      
        

          
          
            # mailer method, it will get over written by the mailer method.
        
      
        

          
          
            #
        
      
        

          
          
            # It is also possible to set these default options that will be used in all mailers through
        
      
        

          
          
            # the <tt>default_options=</tt> configuration in <tt>config/application.rb</tt>:
        
      
        

          
          
            #
        
      
        

          
          
            #    config.action_mailer.default_options = { from: "no-reply@example.org" }
        
      
        

          
          
            #
        
      
        

          
          
            # = Callbacks
        
      
        

          
          
            #
        
      
        

          
          
            # You can specify callbacks using before_action and after_action for configuring your messages.
        
      
        

          
          
            # This may be useful, for example, when you want to add default inline attachments for all
        
      
        

          
          
            # messages sent out by a certain mailer class:
        
      
        

          
          
            #
        
      
        

          
          
            #   class Notifier < ApplicationMailer
        
      
        

          
          
            #     before_action :add_inline_attachment!
        
      
        

          
          
            #
        
      
        

          
          
            #     def welcome
        
      
        

          
          
            #       mail
        
      
        

          
          
            #     end
        
      
        

          
          
            #
        
      
        

          
          
            #     private
        
      
        

          
          
            #
        
      
        

          
          
            #       def add_inline_attachment!
        
      
        

          
          
            #         attachments.inline["footer.jpg"] = File.read('/path/to/filename.jpg')
        
      
        

          
          
            #       end
        
      
        

          
          
            #   end
        
      
        

          
          
            #
        
      
        

          
          
            # Callbacks in Action Mailer are implemented using
        
      
        

          
          
            # <tt>AbstractController::Callbacks</tt>, so you can define and configure
        
      
        

          
          
            # callbacks in the same manner that you would use callbacks in classes that
        
      
        

          
          
            # inherit from <tt>ActionController::Base</tt>.
        
      
        

          
          
            #
        
      
        

          
          
            # Note that unless you have a specific reason to do so, you should prefer using before_action
        
      
        

          
          
            # rather than after_action in your Action Mailer classes so that headers are parsed properly.
        
      
        

          
          
            #
        
      
        

          
          
            # = Previewing emails
        
      
        

          
          
            #
        
      
        

          
          
            # You can preview your email templates visually by adding a mailer preview file to the
        
      
        

          
          
            # <tt>ActionMailer::Base.preview_path</tt>. Since most emails do something interesting
        
      
        

          
          
            # with database data, you'll need to write some scenarios to load messages with fake data:
        
      
        

          
          
            #
        
      
        

          
          
            #   class NotifierPreview < ActionMailer::Preview
        
      
        

          
          
            #     def welcome
        
      
        

          
          
            #       Notifier.welcome(User.first)
        
      
        

          
          
            #     end
        
      
        

          
          
            #   end
        
      
        

          
          
            #
        
      
        

          
          
            # Methods must return a <tt>Mail::Message</tt> object which can be generated by calling the mailer
        
      
        

          
          
            # method without the additional <tt>deliver_now</tt> / <tt>deliver_later</tt>. The location of the
        
      
        

          
          
            # mailer previews directory can be configured using the <tt>preview_path</tt> option which has a default
        
      
        

          
          
            # of <tt>test/mailers/previews</tt>:
        
      
        

          
          
            #
        
      
        

          
          
            #   config.action_mailer.preview_path = "#{Rails.root}/lib/mailer_previews"
        
      
        

          
          
            #
        
      
        

          
          
            # An overview of all previews is accessible at <tt>http://localhost:3000/rails/mailers</tt>
        
      
        

          
          
            # on a running development server instance.
        
      
        

          
          
            #
        
      
        

          
          
            # Previews can also be intercepted in a similar manner as deliveries can be by registering
        
      
        

          
          
            # a preview interceptor that has a <tt>previewing_email</tt> method:
        
      
        

          
          
            #
        
      
        

          
          
            #   class CssInlineStyler
        
      
        

          
          
            #     def self.previewing_email(message)
        
      
        

          
          
            #       # inline CSS styles
        
      
        

          
          
            #     end
        
      
        

          
          
            #   end
        
      
        

          
          
            #
        
      
        

          
          
            #   config.action_mailer.preview_interceptors :css_inline_styler
        
      
        

          
          
            #
        
      
        

          
          
            # Note that interceptors need to be registered both with <tt>register_interceptor</tt>
        
      
        

          
          
            # and <tt>register_preview_interceptor</tt> if they should operate on both sending and
        
      
        

          
          
            # previewing emails.
        
      
        

          
          
            #
        
      
        

          
          
            # = Configuration options
        
      
        

          
          
            #
        
      
        

          
          
            # These options are specified on the class level, like
        
      
        

          
          
            # <tt>ActionMailer::Base.raise_delivery_errors = true</tt>
        
      
        

          
          
            #
        
      
        

          
          
            # * <tt>default_options</tt> - You can pass this in at a class level as well as within the class itself as
        
      
        

          
          
            #   per the above section.
        
      
        

          
          
            #
        
      
        

          
          
            # * <tt>logger</tt> - the logger is used for generating information on the mailing run if available.
        
      
        

          
          
            #   Can be set to +nil+ for no logging. Compatible with both Ruby's own +Logger+ and Log4r loggers.
        
      
        

          
          
            #
        
      
        

          
          
            # * <tt>smtp_settings</tt> - Allows detailed configuration for <tt>:smtp</tt> delivery method:
        
      
        

          
          
            #   * <tt>:address</tt> - Allows you to use a remote mail server. Just change it from its default
        
      
        

          
          
            #     "localhost" setting.
        
      
        

          
          
            #   * <tt>:port</tt> - On the off chance that your mail server doesn't run on port 25, you can change it.
        
      
        

          
          
            #   * <tt>:domain</tt> - If you need to specify a HELO domain, you can do it here.
        
      
        

          
          
            #   * <tt>:user_name</tt> - If your mail server requires authentication, set the username in this setting.
        
      
        

          
          
            #   * <tt>:password</tt> - If your mail server requires authentication, set the password in this setting.
        
      
        

          
          
            #   * <tt>:authentication</tt> - If your mail server requires authentication, you need to specify the
        
      
        

          
          
            #     authentication type here.
        
      
        

          
          
            #     This is a symbol and one of <tt>:plain</tt> (will send the password Base64 encoded), <tt>:login</tt> (will
        
      
        

          
          
            #     send the password Base64 encoded) or <tt>:cram_md5</tt> (combines a Challenge/Response mechanism to exchange
        
      
        

          
          
            #     information and a cryptographic Message Digest 5 algorithm to hash important information)
        
      
        

          
          
            #   * <tt>:enable_starttls_auto</tt> - Detects if STARTTLS is enabled in your SMTP server and starts
        
      
        

          
          
            #     to use it. Defaults to <tt>true</tt>.
        
      
        

          
          
            #   * <tt>:openssl_verify_mode</tt> - When using TLS, you can set how OpenSSL checks the certificate. This is
        
      
        

          
          
            #     really useful if you need to validate a self-signed and/or a wildcard certificate. You can use the name
        
      
        

          
          
            #     of an OpenSSL verify constant (<tt>'none'</tt>, <tt>'peer'</tt>, <tt>'client_once'</tt>,
        
      
        

          
          
            #     <tt>'fail_if_no_peer_cert'</tt>) or directly the constant (<tt>OpenSSL::SSL::VERIFY_NONE</tt>,
        
      
        

          
          
            #     <tt>OpenSSL::SSL::VERIFY_PEER</tt>, ...).
        
      
        

          
          
            #
        
      
        

          
          
            # * <tt>sendmail_settings</tt> - Allows you to override options for the <tt>:sendmail</tt> delivery method.
        
      
        

          
          
            #   * <tt>:location</tt> - The location of the sendmail executable. Defaults to <tt>/usr/sbin/sendmail</tt>.
        
      
        

          
          
            #   * <tt>:arguments</tt> - The command line arguments. Defaults to <tt>-i -t</tt> with <tt>-f sender@address</tt>
        
      
        

          
          
            #     added automatically before the message is sent.
        
      
        

          
          
            #
        
      
        

          
          
            # * <tt>file_settings</tt> - Allows you to override options for the <tt>:file</tt> delivery method.
        
      
        

          
          
            #   * <tt>:location</tt> - The directory into which emails will be written. Defaults to the application
        
      
        

          
          
            #     <tt>tmp/mails</tt>.
        
      
        

          
          
            #
        
      
        

          
          
            # * <tt>raise_delivery_errors</tt> - Whether or not errors should be raised if the email fails to be delivered.
        
      
        

          
          
            #
        
      
        

          
          
            # * <tt>delivery_method</tt> - Defines a delivery method. Possible values are <tt>:smtp</tt> (default),
        
      
        

          
          
            #   <tt>:sendmail</tt>, <tt>:test</tt>, and <tt>:file</tt>. Or you may provide a custom delivery method
        
      
        

          
          
            #   object e.g. +MyOwnDeliveryMethodClass+. See the Mail gem documentation on the interface you need to
        
      
        

          
          
            #   implement for a custom delivery agent.
        
      
        

          
          
            #
        
      
        

          
          
            # * <tt>perform_deliveries</tt> - Determines whether emails are actually sent from Action Mailer when you
        
      
        

          
          
            #   call <tt>.deliver</tt> on an email message or on an Action Mailer method. This is on by default but can
        
      
        

          
          
            #   be turned off to aid in functional testing.
        
      
        

          
          
            #
        
      
        

          
          
            # * <tt>deliveries</tt> - Keeps an array of all the emails sent out through the Action Mailer with
        
      
        

          
          
            #   <tt>delivery_method :test</tt>. Most useful for unit and functional testing.
        
      
        

          2
          
            class Base < AbstractController::Base
        
      
        

          2
          
              include DeliveryMethods
        
      
        

          2
          
              include Previews
        
      
        

          
          
          
        
      
        

          2
          
              abstract!
        
      
        

          
          
          
        
      
        

          2
          
              include AbstractController::Rendering
        
      
        

          
          
          
        
      
        

          2
          
              include AbstractController::Logger
        
      
        

          2
          
              include AbstractController::Helpers
        
      
        

          2
          
              include AbstractController::Translation
        
      
        

          2
          
              include AbstractController::AssetPaths
        
      
        

          2
          
              include AbstractController::Callbacks
        
      
        

          
          
          
        
      
        

          2
          
              include ActionView::Layouts
        
      
        

          
          
          
        
      
        

          2
          
              PROTECTED_IVARS = AbstractController::Rendering::DEFAULT_PROTECTED_INSTANCE_VARIABLES + [:@_action_has_layout]
        
      
        

          
          
          
        
      
        

          2
          
              def _protected_ivars # :nodoc:
        
      
        

          
          
                PROTECTED_IVARS
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          2
          
              helper ActionMailer::MailHelper
        
      
        

          
          
          
        
      
        

          2
          
              private_class_method :new #:nodoc:
        
      
        

          
          
          
        
      
        

          2
          
              class_attribute :default_params
        
      
        

          2
          
              self.default_params = {
        
      
        

          
          
                mime_version: "1.0",
        
      
        

          
          
                charset:      "UTF-8",
        
      
        

          
          
                content_type: "text/plain",
        
      
        

          
          
                parts_order:  [ "text/plain", "text/enriched", "text/html" ]
        
      
        

          
          
              }.freeze
        
      
        

          
          
          
        
      
        

          2
          
              class << self
        
      
        

          
          
                # Register one or more Observers which will be notified when mail is delivered.
        
      
        

          2
          
                def register_observers(*observers)
        
      
        

          2
          
                  observers.flatten.compact.each { |observer| register_observer(observer) }
        
      
        

          
          
                end
        
      
        

          
          
          
        
      
        

          
          
                # Register one or more Interceptors which will be called before mail is sent.
        
      
        

          2
          
                def register_interceptors(*interceptors)
        
      
        

          2
          
                  interceptors.flatten.compact.each { |interceptor| register_interceptor(interceptor) }
        
      
        

          
          
                end
        
      
        

          
          
          
        
      
        

          
          
                # Register an Observer which will be notified when mail is delivered.
        
      
        

          
          
                # Either a class, string or symbol can be passed in as the Observer.
        
      
        

          
          
                # If a string or symbol is passed in it will be camelized and constantized.
        
      
        

          2
          
                def register_observer(observer)
        
      
        

          
          
                  delivery_observer = case observer
        
      
        

          
          
                    when String, Symbol
        
      
        

          
          
                      observer.to_s.camelize.constantize
        
      
        

          
          
                    else
        
      
        

          
          
                      observer
        
      
        

          
          
                    end
        
      
        

          
          
          
        
      
        

          
          
                  Mail.register_observer(delivery_observer)
        
      
        

          
          
                end
        
      
        

          
          
          
        
      
        

          
          
                # Register an Interceptor which will be called before mail is sent.
        
      
        

          
          
                # Either a class, string or symbol can be passed in as the Interceptor.
        
      
        

          
          
                # If a string or symbol is passed in it will be camelized and constantized.
        
      
        

          2
          
                def register_interceptor(interceptor)
        
      
        

          
          
                  delivery_interceptor = case interceptor
        
      
        

          
          
                    when String, Symbol
        
      
        

          
          
                      interceptor.to_s.camelize.constantize
        
      
        

          
          
                    else
        
      
        

          
          
                      interceptor
        
      
        

          
          
                    end
        
      
        

          
          
          
        
      
        

          
          
                  Mail.register_interceptor(delivery_interceptor)
        
      
        

          
          
                end
        
      
        

          
          
          
        
      
        

          
          
                # Returns the name of current mailer. This method is also being used as a path for a view lookup.
        
      
        

          
          
                # If this is an anonymous mailer, this method will return +anonymous+ instead.
        
      
        

          2
          
                def mailer_name
        
      
        

          
          
                  @mailer_name ||= anonymous? ? "anonymous" : name.underscore
        
      
        

          
          
                end
        
      
        

          
          
                # Allows to set the name of current mailer.
        
      
        

          2
          
                attr_writer :mailer_name
        
      
        

          2
          
                alias :controller_path :mailer_name
        
      
        

          
          
          
        
      
        

          
          
                # Sets the defaults through app configuration:
        
      
        

          
          
                #
        
      
        

          
          
                #     config.action_mailer.default(from: "no-reply@example.org")
        
      
        

          
          
                #
        
      
        

          
          
                # Aliased by ::default_options=
        
      
        

          2
          
                def default(value = nil)
        
      
        

          
          
                  self.default_params = default_params.merge(value).freeze if value
        
      
        

          
          
                  default_params
        
      
        

          
          
                end
        
      
        

          
          
                # Allows to set defaults through app configuration:
        
      
        

          
          
                #
        
      
        

          
          
                #    config.action_mailer.default_options = { from: "no-reply@example.org" }
        
      
        

          2
          
                alias :default_options= :default
        
      
        

          
          
          
        
      
        

          
          
                # Receives a raw email, parses it into an email object, decodes it,
        
      
        

          
          
                # instantiates a new mailer, and passes the email object to the mailer
        
      
        

          
          
                # object's +receive+ method.
        
      
        

          
          
                #
        
      
        

          
          
                # If you want your mailer to be able to process incoming messages, you'll
        
      
        

          
          
                # need to implement a +receive+ method that accepts the raw email string
        
      
        

          
          
                # as a parameter:
        
      
        

          
          
                #
        
      
        

          
          
                #   class MyMailer < ActionMailer::Base
        
      
        

          
          
                #     def receive(mail)
        
      
        

          
          
                #       # ...
        
      
        

          
          
                #     end
        
      
        

          
          
                #   end
        
      
        

          2
          
                def receive(raw_mail)
        
      
        

          
          
                  ActiveSupport::Notifications.instrument("receive.action_mailer") do |payload|
        
      
        

          
          
                    mail = Mail.new(raw_mail)
        
      
        

          
          
                    set_payload_for_mail(payload, mail)
        
      
        

          
          
                    new.receive(mail)
        
      
        

          
          
                  end
        
      
        

          
          
                end
        
      
        

          
          
          
        
      
        

          
          
                # Wraps an email delivery inside of <tt>ActiveSupport::Notifications</tt> instrumentation.
        
      
        

          
          
                #
        
      
        

          
          
                # This method is actually called by the <tt>Mail::Message</tt> object itself
        
      
        

          
          
                # through a callback when you call <tt>:deliver</tt> on the <tt>Mail::Message</tt>,
        
      
        

          
          
                # calling +deliver_mail+ directly and passing a <tt>Mail::Message</tt> will do
        
      
        

          
          
                # nothing except tell the logger you sent the email.
        
      
        

          2
          
                def deliver_mail(mail) #:nodoc:
        
      
        

          
          
                  ActiveSupport::Notifications.instrument("deliver.action_mailer") do |payload|
        
      
        

          
          
                    set_payload_for_mail(payload, mail)
        
      
        

          
          
                    yield # Let Mail do the delivery actions
        
      
        

          
          
                  end
        
      
        

          
          
                end
        
      
        

          
          
          
        
      
        

          2
          
                def respond_to?(method, include_private = false) #:nodoc:
        
      
        

          6
          
                  super || action_methods.include?(method.to_s)
        
      
        

          
          
                end
        
      
        

          
          
          
        
      
        

          2
          
              protected
        
      
        

          
          
          
        
      
        

          2
          
                def set_payload_for_mail(payload, mail) #:nodoc:
        
      
        

          
          
                  payload[:mailer]     = name
        
      
        

          
          
                  payload[:message_id] = mail.message_id
        
      
        

          
          
                  payload[:subject]    = mail.subject
        
      
        

          
          
                  payload[:to]         = mail.to
        
      
        

          
          
                  payload[:from]       = mail.from
        
      
        

          
          
                  payload[:bcc]        = mail.bcc if mail.bcc.present?
        
      
        

          
          
                  payload[:cc]         = mail.cc  if mail.cc.present?
        
      
        

          
          
                  payload[:date]       = mail.date
        
      
        

          
          
                  payload[:mail]       = mail.encoded
        
      
        

          
          
                end
        
      
        

          
          
          
        
      
        

          2
          
                def method_missing(method_name, *args) # :nodoc:
        
      
        

          
          
                  if action_methods.include?(method_name.to_s)
        
      
        

          
          
                    MessageDelivery.new(self, method_name, *args)
        
      
        

          
          
                  else
        
      
        

          
          
                    super
        
      
        

          
          
                  end
        
      
        

          
          
                end
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          2
          
              attr_internal :message
        
      
        

          
          
          
        
      
        

          
          
              # Instantiate a new mailer object. If +method_name+ is not +nil+, the mailer
        
      
        

          
          
              # will be initialized according to the named method. If not, the mailer will
        
      
        

          
          
              # remain uninitialized (useful when you only need to invoke the "receive"
        
      
        

          
          
              # method, for instance).
        
      
        

          2
          
              def initialize(method_name=nil, *args)
        
      
        

          
          
                super()
        
      
        

          
          
                @_mail_was_called = false
        
      
        

          
          
                @_message = Mail.new
        
      
        

          
          
                process(method_name, *args) if method_name
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          2
          
              def process(method_name, *args) #:nodoc:
        
      
        

          
          
                payload = {
        
      
        

          
          
                  mailer: self.class.name,
        
      
        

          
          
                  action: method_name
        
      
        

          
          
                }
        
      
        

          
          
          
        
      
        

          
          
                ActiveSupport::Notifications.instrument("process.action_mailer", payload) do
        
      
        

          
          
                  lookup_context.skip_default_locale!
        
      
        

          
          
          
        
      
        

          
          
                  super
        
      
        

          
          
                  @_message = NullMail.new unless @_mail_was_called
        
      
        

          
          
                end
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          2
          
              class NullMail #:nodoc:
        
      
        

          2
          
                def body; '' end
        
      
        

          2
          
                def header; {} end
        
      
        

          
          
          
        
      
        

          2
          
                def respond_to?(string, include_all=false)
        
      
        

          
          
                  true
        
      
        

          
          
                end
        
      
        

          
          
          
        
      
        

          2
          
                def method_missing(*args)
        
      
        

          
          
                  nil
        
      
        

          
          
                end
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          
          
              # Returns the name of the mailer object.
        
      
        

          2
          
              def mailer_name
        
      
        

          
          
                self.class.mailer_name
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          
          
              # Allows you to pass random and unusual headers to the new <tt>Mail::Message</tt>
        
      
        

          
          
              # object which will add them to itself.
        
      
        

          
          
              #
        
      
        

          
          
              #   headers['X-Special-Domain-Specific-Header'] = "SecretValue"
        
      
        

          
          
              #
        
      
        

          
          
              # You can also pass a hash into headers of header field names and values,
        
      
        

          
          
              # which will then be set on the <tt>Mail::Message</tt> object:
        
      
        

          
          
              #
        
      
        

          
          
              #   headers 'X-Special-Domain-Specific-Header' => "SecretValue",
        
      
        

          
          
              #           'In-Reply-To' => incoming.message_id
        
      
        

          
          
              #
        
      
        

          
          
              # The resulting <tt>Mail::Message</tt> will have the following in its header:
        
      
        

          
          
              #
        
      
        

          
          
              #   X-Special-Domain-Specific-Header: SecretValue
        
      
        

          
          
              #
        
      
        

          
          
              # Note about replacing already defined headers:
        
      
        

          
          
              #
        
      
        

          
          
              # * +subject+
        
      
        

          
          
              # * +sender+
        
      
        

          
          
              # * +from+
        
      
        

          
          
              # * +to+
        
      
        

          
          
              # * +cc+
        
      
        

          
          
              # * +bcc+
        
      
        

          
          
              # * +reply-to+
        
      
        

          
          
              # * +orig-date+
        
      
        

          
          
              # * +message-id+
        
      
        

          
          
              # * +references+
        
      
        

          
          
              #
        
      
        

          
          
              # Fields can only appear once in email headers while other fields such as
        
      
        

          
          
              # <tt>X-Anything</tt> can appear multiple times.
        
      
        

          
          
              #
        
      
        

          
          
              # If you want to replace any header which already exists, first set it to
        
      
        

          
          
              # +nil+ in order to reset the value otherwise another field will be added
        
      
        

          
          
              # for the same header.
        
      
        

          2
          
              def headers(args = nil)
        
      
        

          
          
                if args
        
      
        

          
          
                  @_message.headers(args)
        
      
        

          
          
                else
        
      
        

          
          
                  @_message
        
      
        

          
          
                end
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          
          
              # Allows you to add attachments to an email, like so:
        
      
        

          
          
              #
        
      
        

          
          
              #  mail.attachments['filename.jpg'] = File.read('/path/to/filename.jpg')
        
      
        

          
          
              #
        
      
        

          
          
              # If you do this, then Mail will take the file name and work out the mime type
        
      
        

          
          
              # set the Content-Type, Content-Disposition, Content-Transfer-Encoding and
        
      
        

          
          
              # base64 encode the contents of the attachment all for you.
        
      
        

          
          
              #
        
      
        

          
          
              # You can also specify overrides if you want by passing a hash instead of a string:
        
      
        

          
          
              #
        
      
        

          
          
              #  mail.attachments['filename.jpg'] = {mime_type: 'application/x-gzip',
        
      
        

          
          
              #                                      content: File.read('/path/to/filename.jpg')}
        
      
        

          
          
              #
        
      
        

          
          
              # If you want to use a different encoding than Base64, you can pass an encoding in,
        
      
        

          
          
              # but then it is up to you to pass in the content pre-encoded, and don't expect
        
      
        

          
          
              # Mail to know how to decode this data:
        
      
        

          
          
              #
        
      
        

          
          
              #  file_content = SpecialEncode(File.read('/path/to/filename.jpg'))
        
      
        

          
          
              #  mail.attachments['filename.jpg'] = {mime_type: 'application/x-gzip',
        
      
        

          
          
              #                                      encoding: 'SpecialEncoding',
        
      
        

          
          
              #                                      content: file_content }
        
      
        

          
          
              #
        
      
        

          
          
              # You can also search for specific attachments:
        
      
        

          
          
              #
        
      
        

          
          
              #  # By Filename
        
      
        

          
          
              #  mail.attachments['filename.jpg']   # => Mail::Part object or nil
        
      
        

          
          
              #
        
      
        

          
          
              #  # or by index
        
      
        

          
          
              #  mail.attachments[0]                # => Mail::Part (first attachment)
        
      
        

          
          
              #
        
      
        

          2
          
              def attachments
        
      
        

          
          
                if @_mail_was_called
        
      
        

          
          
                  LateAttachmentsProxy.new(@_message.attachments)
        
      
        

          
          
                else
        
      
        

          
          
                  @_message.attachments
        
      
        

          
          
                end
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          2
          
              class LateAttachmentsProxy < SimpleDelegator
        
      
        

          2
          
                def inline; _raise_error end
        
      
        

          2
          
                def []=(_name, _content); _raise_error end
        
      
        

          
          
          
        
      
        

          2
          
                private
        
      
        

          2
          
                  def _raise_error
        
      
        

          
          
                    raise RuntimeError, "Can't add attachments after `mail` was called.\n" \
        
      
        

          
          
                                        "Make sure to use `attachments[]=` before calling `mail`."
        
      
        

          
          
                  end
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          
          
              # The main method that creates the message and renders the email templates. There are
        
      
        

          
          
              # two ways to call this method, with a block, or without a block.
        
      
        

          
          
              #
        
      
        

          
          
              # It accepts a headers hash. This hash allows you to specify
        
      
        

          
          
              # the most used headers in an email message, these are:
        
      
        

          
          
              #
        
      
        

          
          
              # * +:subject+ - The subject of the message, if this is omitted, Action Mailer will
        
      
        

          
          
              #   ask the Rails I18n class for a translated +:subject+ in the scope of
        
      
        

          
          
              #   <tt>[mailer_scope, action_name]</tt> or if this is missing, will translate the
        
      
        

          
          
              #   humanized version of the +action_name+
        
      
        

          
          
              # * +:to+ - Who the message is destined for, can be a string of addresses, or an array
        
      
        

          
          
              #   of addresses.
        
      
        

          
          
              # * +:from+ - Who the message is from
        
      
        

          
          
              # * +:cc+ - Who you would like to Carbon-Copy on this email, can be a string of addresses,
        
      
        

          
          
              #   or an array of addresses.
        
      
        

          
          
              # * +:bcc+ - Who you would like to Blind-Carbon-Copy on this email, can be a string of
        
      
        

          
          
              #   addresses, or an array of addresses.
        
      
        

          
          
              # * +:reply_to+ - Who to set the Reply-To header of the email to.
        
      
        

          
          
              # * +:date+ - The date to say the email was sent on.
        
      
        

          
          
              #
        
      
        

          
          
              # You can set default values for any of the above headers (except +:date+)
        
      
        

          
          
              # by using the ::default class method:
        
      
        

          
          
              #
        
      
        

          
          
              #  class Notifier < ActionMailer::Base
        
      
        

          
          
              #    default from: 'no-reply@test.lindsaar.net',
        
      
        

          
          
              #            bcc: 'email_logger@test.lindsaar.net',
        
      
        

          
          
              #            reply_to: 'bounces@test.lindsaar.net'
        
      
        

          
          
              #  end
        
      
        

          
          
              #
        
      
        

          
          
              # If you need other headers not listed above, you can either pass them in
        
      
        

          
          
              # as part of the headers hash or use the <tt>headers['name'] = value</tt>
        
      
        

          
          
              # method.
        
      
        

          
          
              #
        
      
        

          
          
              # When a +:return_path+ is specified as header, that value will be used as
        
      
        

          
          
              # the 'envelope from' address for the Mail message. Setting this is useful
        
      
        

          
          
              # when you want delivery notifications sent to a different address than the
        
      
        

          
          
              # one in +:from+. Mail will actually use the +:return_path+ in preference
        
      
        

          
          
              # to the +:sender+ in preference to the +:from+ field for the 'envelope
        
      
        

          
          
              # from' value.
        
      
        

          
          
              #
        
      
        

          
          
              # If you do not pass a block to the +mail+ method, it will find all
        
      
        

          
          
              # templates in the view paths using by default the mailer name and the
        
      
        

          
          
              # method name that it is being called from, it will then create parts for
        
      
        

          
          
              # each of these templates intelligently, making educated guesses on correct
        
      
        

          
          
              # content type and sequence, and return a fully prepared <tt>Mail::Message</tt>
        
      
        

          
          
              # ready to call <tt>:deliver</tt> on to send.
        
      
        

          
          
              #
        
      
        

          
          
              # For example:
        
      
        

          
          
              #
        
      
        

          
          
              #   class Notifier < ActionMailer::Base
        
      
        

          
          
              #     default from: 'no-reply@test.lindsaar.net'
        
      
        

          
          
              #
        
      
        

          
          
              #     def welcome
        
      
        

          
          
              #       mail(to: 'mikel@test.lindsaar.net')
        
      
        

          
          
              #     end
        
      
        

          
          
              #   end
        
      
        

          
          
              #
        
      
        

          
          
              # Will look for all templates at "app/views/notifier" with name "welcome".
        
      
        

          
          
              # If no welcome template exists, it will raise an ActionView::MissingTemplate error.
        
      
        

          
          
              #
        
      
        

          
          
              # However, those can be customized:
        
      
        

          
          
              #
        
      
        

          
          
              #   mail(template_path: 'notifications', template_name: 'another')
        
      
        

          
          
              #
        
      
        

          
          
              # And now it will look for all templates at "app/views/notifications" with name "another".
        
      
        

          
          
              #
        
      
        

          
          
              # If you do pass a block, you can render specific templates of your choice:
        
      
        

          
          
              #
        
      
        

          
          
              #   mail(to: 'mikel@test.lindsaar.net') do |format|
        
      
        

          
          
              #     format.text
        
      
        

          
          
              #     format.html
        
      
        

          
          
              #   end
        
      
        

          
          
              #
        
      
        

          
          
              # You can even render plain text directly without using a template:
        
      
        

          
          
              #
        
      
        

          
          
              #   mail(to: 'mikel@test.lindsaar.net') do |format|
        
      
        

          
          
              #     format.text { render plain: "Hello Mikel!" }
        
      
        

          
          
              #     format.html { render html: "<h1>Hello Mikel!</h1>".html_safe }
        
      
        

          
          
              #   end
        
      
        

          
          
              #
        
      
        

          
          
              # Which will render a +multipart/alternative+ email with +text/plain+ and
        
      
        

          
          
              # +text/html+ parts.
        
      
        

          
          
              #
        
      
        

          
          
              # The block syntax also allows you to customize the part headers if desired:
        
      
        

          
          
              #
        
      
        

          
          
              #   mail(to: 'mikel@test.lindsaar.net') do |format|
        
      
        

          
          
              #     format.text(content_transfer_encoding: "base64")
        
      
        

          
          
              #     format.html
        
      
        

          
          
              #   end
        
      
        

          
          
              #
        
      
        

          2
          
              def mail(headers = {}, &block)
        
      
        

          
          
                return @_message if @_mail_was_called && headers.blank? && !block
        
      
        

          
          
          
        
      
        

          
          
                m = @_message
        
      
        

          
          
          
        
      
        

          
          
                # At the beginning, do not consider class default for content_type
        
      
        

          
          
                content_type = headers[:content_type]
        
      
        

          
          
          
        
      
        

          
          
                # Call all the procs (if any)
        
      
        

          
          
                default_values = {}
        
      
        

          
          
                self.class.default.each do |k,v|
        
      
        

          
          
                  default_values[k] = v.is_a?(Proc) ? instance_eval(&v) : v
        
      
        

          
          
                end
        
      
        

          
          
          
        
      
        

          
          
                # Handle defaults
        
      
        

          
          
                headers = headers.reverse_merge(default_values)
        
      
        

          
          
                headers[:subject] ||= default_i18n_subject
        
      
        

          
          
          
        
      
        

          
          
                # Apply charset at the beginning so all fields are properly quoted
        
      
        

          
          
                m.charset = charset = headers[:charset]
        
      
        

          
          
          
        
      
        

          
          
                # Set configure delivery behavior
        
      
        

          
          
                wrap_delivery_behavior!(headers.delete(:delivery_method), headers.delete(:delivery_method_options))
        
      
        

          
          
          
        
      
        

          
          
                # Assign all headers except parts_order, content_type and body
        
      
        

          
          
                assignable = headers.except(:parts_order, :content_type, :body, :template_name, :template_path)
        
      
        

          
          
                assignable.each { |k, v| m[k] = v }
        
      
        

          
          
          
        
      
        

          
          
                # Render the templates and blocks
        
      
        

          
          
                responses = collect_responses(headers, &block)
        
      
        

          
          
                @_mail_was_called = true
        
      
        

          
          
          
        
      
        

          
          
                create_parts_from_responses(m, responses)
        
      
        

          
          
          
        
      
        

          
          
                # Setup content type, reapply charset and handle parts order
        
      
        

          
          
                m.content_type = set_content_type(m, content_type, headers[:content_type])
        
      
        

          
          
                m.charset      = charset
        
      
        

          
          
          
        
      
        

          
          
                if m.multipart?
        
      
        

          
          
                  m.body.set_sort_order(headers[:parts_order])
        
      
        

          
          
                  m.body.sort_parts!
        
      
        

          
          
                end
        
      
        

          
          
          
        
      
        

          
          
                m
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          2
          
            protected
        
      
        

          
          
          
        
      
        

          
          
              # Used by #mail to set the content type of the message.
        
      
        

          
          
              #
        
      
        

          
          
              # It will use the given +user_content_type+, or multipart if the mail
        
      
        

          
          
              # message has any attachments. If the attachments are inline, the content
        
      
        

          
          
              # type will be "multipart/related", otherwise "multipart/mixed".
        
      
        

          
          
              #
        
      
        

          
          
              # If there is no content type passed in via headers, and there are no
        
      
        

          
          
              # attachments, or the message is multipart, then the default content type is
        
      
        

          
          
              # used.
        
      
        

          2
          
              def set_content_type(m, user_content_type, class_default)
        
      
        

          
          
                params = m.content_type_parameters || {}
        
      
        

          
          
                case
        
      
        

          
          
                when user_content_type.present?
        
      
        

          
          
                  user_content_type
        
      
        

          
          
                when m.has_attachments?
        
      
        

          
          
                  if m.attachments.detect { |a| a.inline? }
        
      
        

          
          
                    ["multipart", "related", params]
        
      
        

          
          
                  else
        
      
        

          
          
                    ["multipart", "mixed", params]
        
      
        

          
          
                  end
        
      
        

          
          
                when m.multipart?
        
      
        

          
          
                  ["multipart", "alternative", params]
        
      
        

          
          
                else
        
      
        

          
          
                  m.content_type || class_default
        
      
        

          
          
                end
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          
          
              # Translates the +subject+ using Rails I18n class under <tt>[mailer_scope, action_name]</tt> scope.
        
      
        

          
          
              # If it does not find a translation for the +subject+ under the specified scope it will default to a
        
      
        

          
          
              # humanized version of the <tt>action_name</tt>.
        
      
        

          
          
              # If the subject has interpolations, you can pass them through the +interpolations+ parameter.
        
      
        

          2
          
              def default_i18n_subject(interpolations = {})
        
      
        

          
          
                mailer_scope = self.class.mailer_name.tr('/', '.')
        
      
        

          
          
                I18n.t(:subject, interpolations.merge(scope: [mailer_scope, action_name], default: action_name.humanize))
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          2
          
              def collect_responses(headers) #:nodoc:
        
      
        

          
          
                responses = []
        
      
        

          
          
          
        
      
        

          
          
                if block_given?
        
      
        

          
          
                  collector = ActionMailer::Collector.new(lookup_context) { render(action_name) }
        
      
        

          
          
                  yield(collector)
        
      
        

          
          
                  responses = collector.responses
        
      
        

          
          
                elsif headers[:body]
        
      
        

          
          
                  responses << {
        
      
        

          
          
                    body: headers.delete(:body),
        
      
        

          
          
                    content_type: self.class.default[:content_type] || "text/plain"
        
      
        

          
          
                  }
        
      
        

          
          
                else
        
      
        

          
          
                  templates_path = headers.delete(:template_path) || self.class.mailer_name
        
      
        

          
          
                  templates_name = headers.delete(:template_name) || action_name
        
      
        

          
          
          
        
      
        

          
          
                  each_template(Array(templates_path), templates_name) do |template|
        
      
        

          
          
                    self.formats = template.formats
        
      
        

          
          
          
        
      
        

          
          
                    responses << {
        
      
        

          
          
                      body: render(template: template),
        
      
        

          
          
                      content_type: template.type.to_s
        
      
        

          
          
                    }
        
      
        

          
          
                  end
        
      
        

          
          
                end
        
      
        

          
          
          
        
      
        

          
          
                responses
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          2
          
              def each_template(paths, name, &block) #:nodoc:
        
      
        

          
          
                templates = lookup_context.find_all(name, paths)
        
      
        

          
          
                if templates.empty?
        
      
        

          
          
                  raise ActionView::MissingTemplate.new(paths, name, paths, false, 'mailer')
        
      
        

          
          
                else
        
      
        

          
          
                  templates.uniq { |t| t.formats }.each(&block)
        
      
        

          
          
                end
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          2
          
              def create_parts_from_responses(m, responses) #:nodoc:
        
      
        

          
          
                if responses.size == 1 && !m.has_attachments?
        
      
        

          
          
                  responses[0].each { |k,v| m[k] = v }
        
      
        

          
          
                elsif responses.size > 1 && m.has_attachments?
        
      
        

          
          
                  container = Mail::Part.new
        
      
        

          
          
                  container.content_type = "multipart/alternative"
        
      
        

          
          
                  responses.each { |r| insert_part(container, r, m.charset) }
        
      
        

          
          
                  m.add_part(container)
        
      
        

          
          
                else
        
      
        

          
          
                  responses.each { |r| insert_part(m, r, m.charset) }
        
      
        

          
          
                end
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          2
          
              def insert_part(container, response, charset) #:nodoc:
        
      
        

          
          
                response[:charset] ||= charset
        
      
        

          
          
                part = Mail::Part.new(response)
        
      
        

          
          
                container.add_part(part)
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          
          
              # Emails do not support relative path links.
        
      
        

          2
          
              def self.supports_path?
        
      
        

          
          
                false
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          2
          
              ActiveSupport.run_load_hooks(:action_mailer, self)
        
      
        

          
          
            end
        
      
        

          
          
          end
        
      
    
  

    

      
        

          2
          
          require 'abstract_controller/collector'
        
      
        

          2
          
          require 'active_support/core_ext/hash/reverse_merge'
        
      
        

          2
          
          require 'active_support/core_ext/array/extract_options'
        
      
        

          
          
          
        
      
        

          2
          
          module ActionMailer
        
      
        

          2
          
            class Collector
        
      
        

          2
          
              include AbstractController::Collector
        
      
        

          2
          
              attr_reader :responses
        
      
        

          
          
          
        
      
        

          2
          
              def initialize(context, &block)
        
      
        

          
          
                @context = context
        
      
        

          
          
                @responses = []
        
      
        

          
          
                @default_render = block
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          2
          
              def any(*args, &block)
        
      
        

          
          
                options = args.extract_options!
        
      
        

          
          
                raise ArgumentError, "You have to supply at least one format" if args.empty?
        
      
        

          
          
                args.each { |type| send(type, options.dup, &block) }
        
      
        

          
          
              end
        
      
        

          2
          
              alias :all :any
        
      
        

          
          
          
        
      
        

          2
          
              def custom(mime, options = {})
        
      
        

          
          
                options.reverse_merge!(content_type: mime.to_s)
        
      
        

          
          
                @context.formats = [mime.to_sym]
        
      
        

          
          
                options[:body] = block_given? ? yield : @default_render.call
        
      
        

          
          
                @responses << options
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          end
        
      
    
  

    

      
        

          2
          
          require 'tmpdir'
        
      
        

          
          
          
        
      
        

          2
          
          module ActionMailer
        
      
        

          
          
            # This module handles everything related to mail delivery, from registering
        
      
        

          
          
            # new delivery methods to configuring the mail object to be sent.
        
      
        

          2
          
            module DeliveryMethods
        
      
        

          2
          
              extend ActiveSupport::Concern
        
      
        

          
          
          
        
      
        

          2
          
              included do
        
      
        

          2
          
                class_attribute :delivery_methods, :delivery_method
        
      
        

          
          
          
        
      
        

          
          
                # Do not make this inheritable, because we always want it to propagate
        
      
        

          2
          
                cattr_accessor :raise_delivery_errors
        
      
        

          2
          
                self.raise_delivery_errors = true
        
      
        

          
          
          
        
      
        

          2
          
                cattr_accessor :perform_deliveries
        
      
        

          2
          
                self.perform_deliveries = true
        
      
        

          
          
          
        
      
        

          2
          
                self.delivery_methods = {}.freeze
        
      
        

          2
          
                self.delivery_method  = :smtp
        
      
        

          
          
          
        
      
        

          2
          
                add_delivery_method :smtp, Mail::SMTP,
        
      
        

          
          
                  address:              "localhost",
        
      
        

          
          
                  port:                 25,
        
      
        

          
          
                  domain:               'localhost.localdomain',
        
      
        

          
          
                  user_name:            nil,
        
      
        

          
          
                  password:             nil,
        
      
        

          
          
                  authentication:       nil,
        
      
        

          
          
                  enable_starttls_auto: true
        
      
        

          
          
          
        
      
        

          2
          
                add_delivery_method :file, Mail::FileDelivery,
        
      
        

          
          
                  location: defined?(Rails.root) ? "#{Rails.root}/tmp/mails" : "#{Dir.tmpdir}/mails"
        
      
        

          
          
          
        
      
        

          2
          
                add_delivery_method :sendmail, Mail::Sendmail,
        
      
        

          
          
                  location:  '/usr/sbin/sendmail',
        
      
        

          
          
                  arguments: '-i -t'
        
      
        

          
          
          
        
      
        

          2
          
                add_delivery_method :test, Mail::TestMailer
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          
          
              # Helpers for creating and wrapping delivery behavior, used by DeliveryMethods.
        
      
        

          2
          
              module ClassMethods
        
      
        

          
          
                # Provides a list of emails that have been delivered by Mail::TestMailer
        
      
        

          2
          
                delegate :deliveries, :deliveries=, to: Mail::TestMailer
        
      
        

          
          
          
        
      
        

          
          
                # Adds a new delivery method through the given class using the given
        
      
        

          
          
                # symbol as alias and the default options supplied.
        
      
        

          
          
                #
        
      
        

          
          
                #   add_delivery_method :sendmail, Mail::Sendmail,
        
      
        

          
          
                #     location:  '/usr/sbin/sendmail',
        
      
        

          
          
                #     arguments: '-i -t'
        
      
        

          2
          
                def add_delivery_method(symbol, klass, default_options={})
        
      
        

          8
          
                  class_attribute(:"#{symbol}_settings") unless respond_to?(:"#{symbol}_settings")
        
      
        

          8
          
                  send(:"#{symbol}_settings=", default_options)
        
      
        

          8
          
                  self.delivery_methods = delivery_methods.merge(symbol.to_sym => klass).freeze
        
      
        

          
          
                end
        
      
        

          
          
          
        
      
        

          2
          
                def wrap_delivery_behavior(mail, method=nil, options=nil) # :nodoc:
        
      
        

          
          
                  method ||= self.delivery_method
        
      
        

          
          
                  mail.delivery_handler = self
        
      
        

          
          
          
        
      
        

          
          
                  case method
        
      
        

          
          
                  when NilClass
        
      
        

          
          
                    raise "Delivery method cannot be nil"
        
      
        

          
          
                  when Symbol
        
      
        

          
          
                    if klass = delivery_methods[method]
        
      
        

          
          
                      mail.delivery_method(klass, (send(:"#{method}_settings") || {}).merge(options || {}))
        
      
        

          
          
                    else
        
      
        

          
          
                      raise "Invalid delivery method #{method.inspect}"
        
      
        

          
          
                    end
        
      
        

          
          
                  else
        
      
        

          
          
                    mail.delivery_method(method)
        
      
        

          
          
                  end
        
      
        

          
          
          
        
      
        

          
          
                  mail.perform_deliveries    = perform_deliveries
        
      
        

          
          
                  mail.raise_delivery_errors = raise_delivery_errors
        
      
        

          
          
                end
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          2
          
              def wrap_delivery_behavior!(*args) # :nodoc:
        
      
        

          
          
                self.class.wrap_delivery_behavior(message, *args)
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          end
        
      
    
  

    

      
        

          2
          
          require 'active_support/log_subscriber'
        
      
        

          
          
          
        
      
        

          2
          
          module ActionMailer
        
      
        

          
          
            # Implements the ActiveSupport::LogSubscriber for logging notifications when
        
      
        

          
          
            # email is delivered and received.
        
      
        

          2
          
            class LogSubscriber < ActiveSupport::LogSubscriber
        
      
        

          
          
              # An email was delivered.
        
      
        

          2
          
              def deliver(event)
        
      
        

          
          
                info do
        
      
        

          
          
                  recipients = Array(event.payload[:to]).join(', ')
        
      
        

          
          
                  "\nSent mail to #{recipients} (#{event.duration.round(1)}ms)"
        
      
        

          
          
                end
        
      
        

          
          
          
        
      
        

          
          
                debug { event.payload[:mail] }
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          
          
              # An email was received.
        
      
        

          2
          
              def receive(event)
        
      
        

          
          
                info { "\nReceived mail (#{event.duration.round(1)}ms)" }
        
      
        

          
          
                debug { event.payload[:mail] }
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          
          
              # An email was generated.
        
      
        

          2
          
              def process(event)
        
      
        

          
          
                debug do
        
      
        

          
          
                  mailer = event.payload[:mailer]
        
      
        

          
          
                  action = event.payload[:action]
        
      
        

          
          
                  "\n#{mailer}##{action}: processed outbound mail in #{event.duration.round(1)}ms"
        
      
        

          
          
                end
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          
          
              # Use the logger configured for ActionMailer::Base
        
      
        

          2
          
              def logger
        
      
        

          
          
                ActionMailer::Base.logger
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          end
        
      
        

          
          
          
        
      
        

          2
          
          ActionMailer::LogSubscriber.attach_to :action_mailer
        
      
    
  

    

      
        

          2
          
          module ActionMailer
        
      
        

          
          
            # Provides helper methods for ActionMailer::Base that can be used for easily
        
      
        

          
          
            # formatting messages, accessing mailer or message instances, and the
        
      
        

          
          
            # attachments list.
        
      
        

          2
          
            module MailHelper
        
      
        

          
          
              # Take the text and format it, indented two spaces for each line, and
        
      
        

          
          
              # wrapped at 72 columns.
        
      
        

          2
          
              def block_format(text)
        
      
        

          
          
                formatted = text.split(/\n\r?\n/).collect { |paragraph|
        
      
        

          
          
                  format_paragraph(paragraph)
        
      
        

          
          
                }.join("\n\n")
        
      
        

          
          
          
        
      
        

          
          
                # Make list points stand on their own line
        
      
        

          
          
                formatted.gsub!(/[ ]*([*]+) ([^*]*)/) { "  #{$1} #{$2.strip}\n" }
        
      
        

          
          
                formatted.gsub!(/[ ]*([#]+) ([^#]*)/) { "  #{$1} #{$2.strip}\n" }
        
      
        

          
          
          
        
      
        

          
          
                formatted
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          
          
              # Access the mailer instance.
        
      
        

          2
          
              def mailer
        
      
        

          
          
                @_controller
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          
          
              # Access the message instance.
        
      
        

          2
          
              def message
        
      
        

          
          
                @_message
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          
          
              # Access the message attachments list.
        
      
        

          2
          
              def attachments
        
      
        

          
          
                mailer.attachments
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          
          
              # Returns +text+ wrapped at +len+ columns and indented +indent+ spaces.
        
      
        

          
          
              #
        
      
        

          
          
              #   my_text = 'Here is a sample text with more than 40 characters'
        
      
        

          
          
              #
        
      
        

          
          
              #   format_paragraph(my_text, 25, 4)
        
      
        

          
          
              #   # => "    Here is a sample text with\n    more than 40 characters"
        
      
        

          2
          
              def format_paragraph(text, len = 72, indent = 2)
        
      
        

          
          
                sentences = [[]]
        
      
        

          
          
          
        
      
        

          
          
                text.split.each do |word|
        
      
        

          
          
                  if sentences.first.present? && (sentences.last + [word]).join(' ').length > len
        
      
        

          
          
                    sentences << [word]
        
      
        

          
          
                  else
        
      
        

          
          
                    sentences.last << word
        
      
        

          
          
                  end
        
      
        

          
          
                end
        
      
        

          
          
          
        
      
        

          
          
                indentation = " " * indent
        
      
        

          
          
                sentences.map! { |sentence|
        
      
        

          
          
                  "#{indentation}#{sentence.join(' ')}"
        
      
        

          
          
                }.join "\n"
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          end
        
      
    
  

    

      
        

          2
          
          require 'active_support/descendants_tracker'
        
      
        

          
          
          
        
      
        

          2
          
          module ActionMailer
        
      
        

          2
          
            module Previews #:nodoc:
        
      
        

          2
          
              extend ActiveSupport::Concern
        
      
        

          
          
          
        
      
        

          2
          
              included do
        
      
        

          
          
                # Set the location of mailer previews through app configuration:
        
      
        

          
          
                #
        
      
        

          
          
                #     config.action_mailer.preview_path = "#{Rails.root}/lib/mailer_previews"
        
      
        

          
          
                #
        
      
        

          2
          
                mattr_accessor :preview_path, instance_writer: false
        
      
        

          
          
          
        
      
        

          
          
                # Enable or disable mailer previews through app configuration:
        
      
        

          
          
                #
        
      
        

          
          
                #     config.action_mailer.show_previews = true
        
      
        

          
          
                #
        
      
        

          
          
                # Defaults to true for development environment
        
      
        

          
          
                #
        
      
        

          2
          
                mattr_accessor :show_previews, instance_writer: false
        
      
        

          
          
          
        
      
        

          
          
                # :nodoc:
        
      
        

          2
          
                mattr_accessor :preview_interceptors, instance_writer: false
        
      
        

          2
          
                self.preview_interceptors = []
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          2
          
              module ClassMethods
        
      
        

          
          
                # Register one or more Interceptors which will be called before mail is previewed.
        
      
        

          2
          
                def register_preview_interceptors(*interceptors)
        
      
        

          2
          
                  interceptors.flatten.compact.each { |interceptor| register_preview_interceptor(interceptor) }
        
      
        

          
          
                end
        
      
        

          
          
          
        
      
        

          
          
                # Register an Interceptor which will be called before mail is previewed.
        
      
        

          
          
                # Either a class or a string can be passed in as the Interceptor. If a
        
      
        

          
          
                # string is passed in it will be <tt>constantize</tt>d.
        
      
        

          2
          
                def register_preview_interceptor(interceptor)
        
      
        

          
          
                  preview_interceptor = case interceptor
        
      
        

          
          
                    when String, Symbol
        
      
        

          
          
                      interceptor.to_s.camelize.constantize
        
      
        

          
          
                    else
        
      
        

          
          
                      interceptor
        
      
        

          
          
                    end
        
      
        

          
          
          
        
      
        

          
          
                  unless preview_interceptors.include?(preview_interceptor)
        
      
        

          
          
                    preview_interceptors << preview_interceptor
        
      
        

          
          
                  end
        
      
        

          
          
                end
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          2
          
            class Preview
        
      
        

          2
          
              extend ActiveSupport::DescendantsTracker
        
      
        

          
          
          
        
      
        

          2
          
              class << self
        
      
        

          
          
                # Returns all mailer preview classes
        
      
        

          2
          
                def all
        
      
        

          
          
                  load_previews if descendants.empty?
        
      
        

          
          
                  descendants
        
      
        

          
          
                end
        
      
        

          
          
          
        
      
        

          
          
                # Returns the mail object for the given email name. The registered preview
        
      
        

          
          
                # interceptors will be informed so that they can transform the message
        
      
        

          
          
                # as they would if the mail was actually being delivered.
        
      
        

          2
          
                def call(email)
        
      
        

          
          
                  preview = self.new
        
      
        

          
          
                  message = preview.public_send(email)
        
      
        

          
          
                  inform_preview_interceptors(message)
        
      
        

          
          
                  message
        
      
        

          
          
                end
        
      
        

          
          
          
        
      
        

          
          
                # Returns all of the available email previews
        
      
        

          2
          
                def emails
        
      
        

          
          
                  public_instance_methods(false).map(&:to_s).sort
        
      
        

          
          
                end
        
      
        

          
          
          
        
      
        

          
          
                # Returns true if the email exists
        
      
        

          2
          
                def email_exists?(email)
        
      
        

          
          
                  emails.include?(email)
        
      
        

          
          
                end
        
      
        

          
          
          
        
      
        

          
          
                # Returns true if the preview exists
        
      
        

          2
          
                def exists?(preview)
        
      
        

          
          
                  all.any?{ |p| p.preview_name == preview }
        
      
        

          
          
                end
        
      
        

          
          
          
        
      
        

          
          
                # Find a mailer preview by its underscored class name
        
      
        

          2
          
                def find(preview)
        
      
        

          
          
                  all.find{ |p| p.preview_name == preview }
        
      
        

          
          
                end
        
      
        

          
          
          
        
      
        

          
          
                # Returns the underscored name of the mailer preview without the suffix
        
      
        

          2
          
                def preview_name
        
      
        

          
          
                  name.sub(/Preview$/, '').underscore
        
      
        

          
          
                end
        
      
        

          
          
          
        
      
        

          2
          
                protected
        
      
        

          2
          
                  def load_previews #:nodoc:
        
      
        

          
          
                    if preview_path
        
      
        

          
          
                      Dir["#{preview_path}/**/*_preview.rb"].each{ |file| require_dependency file }
        
      
        

          
          
                    end
        
      
        

          
          
                  end
        
      
        

          
          
          
        
      
        

          2
          
                  def preview_path #:nodoc:
        
      
        

          
          
                    Base.preview_path
        
      
        

          
          
                  end
        
      
        

          
          
          
        
      
        

          2
          
                  def show_previews #:nodoc:
        
      
        

          
          
                    Base.show_previews
        
      
        

          
          
                  end
        
      
        

          
          
          
        
      
        

          2
          
                  def inform_preview_interceptors(message) #:nodoc:
        
      
        

          
          
                    Base.preview_interceptors.each do |interceptor|
        
      
        

          
          
                      interceptor.previewing_email(message)
        
      
        

          
          
                    end
        
      
        

          
          
                  end
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          end
        
      
    
  

    

      
        

          2
          
          module AbstractController
        
      
        

          2
          
            module AssetPaths #:nodoc:
        
      
        

          2
          
              extend ActiveSupport::Concern
        
      
        

          
          
          
        
      
        

          2
          
              included do
        
      
        

          4
          
                config_accessor :asset_host, :assets_dir, :javascripts_dir,
        
      
        

          
          
                  :stylesheets_dir, :default_asset_host_protocol, :relative_url_root
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          end
        
      
    
  

    

      
        

          2
          
          require 'erubis'
        
      
        

          2
          
          require 'set'
        
      
        

          2
          
          require 'active_support/configurable'
        
      
        

          2
          
          require 'active_support/descendants_tracker'
        
      
        

          2
          
          require 'active_support/core_ext/module/anonymous'
        
      
        

          
          
          
        
      
        

          2
          
          module AbstractController
        
      
        

          2
          
            class Error < StandardError #:nodoc:
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # Raised when a non-existing controller action is triggered.
        
      
        

          2
          
            class ActionNotFound < StandardError
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # <tt>AbstractController::Base</tt> is a low-level API. Nobody should be
        
      
        

          
          
            # using it directly, and subclasses (like ActionController::Base) are
        
      
        

          
          
            # expected to provide their own +render+ method, since rendering means
        
      
        

          
          
            # different things depending on the context.
        
      
        

          2
          
            class Base
        
      
        

          2
          
              attr_internal :response_body
        
      
        

          2
          
              attr_internal :action_name
        
      
        

          2
          
              attr_internal :formats
        
      
        

          
          
          
        
      
        

          2
          
              include ActiveSupport::Configurable
        
      
        

          2
          
              extend ActiveSupport::DescendantsTracker
        
      
        

          
          
          
        
      
        

          2
          
              undef_method :not_implemented
        
      
        

          2
          
              class << self
        
      
        

          2
          
                attr_reader :abstract
        
      
        

          2
          
                alias_method :abstract?, :abstract
        
      
        

          
          
          
        
      
        

          
          
                # Define a controller as abstract. See internal_methods for more
        
      
        

          
          
                # details.
        
      
        

          2
          
                def abstract!
        
      
        

          8
          
                  @abstract = true
        
      
        

          
          
                end
        
      
        

          
          
          
        
      
        

          2
          
                def inherited(klass) # :nodoc:
        
      
        

          
          
                  # Define the abstract ivar on subclasses so that we don't get
        
      
        

          
          
                  # uninitialized ivar warnings
        
      
        

          16
          
                  unless klass.instance_variable_defined?(:@abstract)
        
      
        

          16
          
                    klass.instance_variable_set(:@abstract, false)
        
      
        

          
          
                  end
        
      
        

          16
          
                  super
        
      
        

          
          
                end
        
      
        

          
          
          
        
      
        

          
          
                # A list of all internal methods for a controller. This finds the first
        
      
        

          
          
                # abstract superclass of a controller, and gets a list of all public
        
      
        

          
          
                # instance methods on that abstract class. Public instance methods of
        
      
        

          
          
                # a controller would normally be considered action methods, so methods
        
      
        

          
          
                # declared on abstract classes are being removed.
        
      
        

          
          
                # (ActionController::Metal and ActionController::Base are defined as abstract)
        
      
        

          2
          
                def internal_methods
        
      
        

          5
          
                  controller = self
        
      
        

          
          
          
        
      
        

          5
          
                  controller = controller.superclass until controller.abstract?
        
      
        

          5
          
                  controller.public_instance_methods(true)
        
      
        

          
          
                end
        
      
        

          
          
          
        
      
        

          
          
                # The list of hidden actions. Defaults to an empty array.
        
      
        

          
          
                # This can be modified by other modules or subclasses
        
      
        

          
          
                # to specify particular actions as hidden.
        
      
        

          
          
                #
        
      
        

          
          
                # ==== Returns
        
      
        

          
          
                # * <tt>Array</tt> - An array of method names that should not be considered actions.
        
      
        

          2
          
                def hidden_actions
        
      
        

          2
          
                  []
        
      
        

          
          
                end
        
      
        

          
          
          
        
      
        

          
          
                # A list of method names that should be considered actions. This
        
      
        

          
          
                # includes all public instance methods on a controller, less
        
      
        

          
          
                # any internal methods (see #internal_methods), adding back in
        
      
        

          
          
                # any methods that are internal, but still exist on the class
        
      
        

          
          
                # itself. Finally, #hidden_actions are removed.
        
      
        

          
          
                #
        
      
        

          
          
                # ==== Returns
        
      
        

          
          
                # * <tt>Set</tt> - A set of all methods that should be considered actions.
        
      
        

          2
          
                def action_methods
        
      
        

          
          
                  @action_methods ||= begin
        
      
        

          
          
                    # All public instance methods of this class, including ancestors
        
      
        

          5
          
                    methods = (public_instance_methods(true) -
        
      
        

          
          
                      # Except for public instance methods of Base and its ancestors
        
      
        

          
          
                      internal_methods +
        
      
        

          
          
                      # Be sure to include shadowed public instance methods of this class
        
      
        

          330
          
                      public_instance_methods(false)).uniq.map { |x| x.to_s } -
        
      
        

          
          
                      # And always exclude explicitly hidden actions
        
      
        

          
          
                      hidden_actions.to_a
        
      
        

          
          
          
        
      
        

          
          
                    # Clear out AS callback method pollution
        
      
        

          330
          
                    Set.new(methods.reject { |method| method =~ /_one_time_conditions/ })
        
      
        

          5
          
                  end
        
      
        

          
          
                end
        
      
        

          
          
          
        
      
        

          
          
                # action_methods are cached and there is sometimes need to refresh
        
      
        

          
          
                # them. clear_action_methods! allows you to do that, so next time
        
      
        

          
          
                # you run action_methods, they will be recalculated
        
      
        

          2
          
                def clear_action_methods!
        
      
        

          539
          
                  @action_methods = nil
        
      
        

          
          
                end
        
      
        

          
          
          
        
      
        

          
          
                # Returns the full controller name, underscored, without the ending Controller.
        
      
        

          
          
                # For instance, MyApp::MyPostsController would return "my_app/my_posts" for
        
      
        

          
          
                # controller_path.
        
      
        

          
          
                #
        
      
        

          
          
                # ==== Returns
        
      
        

          
          
                # * <tt>String</tt>
        
      
        

          2
          
                def controller_path
        
      
        

          59
          
                  @controller_path ||= name.sub(/Controller$/, '').underscore unless anonymous?
        
      
        

          
          
                end
        
      
        

          
          
          
        
      
        

          
          
                # Refresh the cached action_methods when a new action_method is added.
        
      
        

          2
          
                def method_added(name)
        
      
        

          539
          
                  super
        
      
        

          539
          
                  clear_action_methods!
        
      
        

          
          
                end
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          2
          
              abstract!
        
      
        

          
          
          
        
      
        

          
          
              # Calls the action going through the entire action dispatch stack.
        
      
        

          
          
              #
        
      
        

          
          
              # The actual method that is called is determined by calling
        
      
        

          
          
              # #method_for_action. If no method can handle the action, then an
        
      
        

          
          
              # AbstractController::ActionNotFound error is raised.
        
      
        

          
          
              #
        
      
        

          
          
              # ==== Returns
        
      
        

          
          
              # * <tt>self</tt>
        
      
        

          2
          
              def process(action, *args)
        
      
        

          29
          
                @_action_name = action.to_s
        
      
        

          
          
          
        
      
        

          29
          
                unless action_name = _find_action_name(@_action_name)
        
      
        

          
          
                  raise ActionNotFound, "The action '#{action}' could not be found for #{self.class.name}"
        
      
        

          
          
                end
        
      
        

          
          
          
        
      
        

          29
          
                @_response_body = nil
        
      
        

          
          
          
        
      
        

          29
          
                process_action(action_name, *args)
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          
          
              # Delegates to the class' #controller_path
        
      
        

          2
          
              def controller_path
        
      
        

          
          
                self.class.controller_path
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          
          
              # Delegates to the class' #action_methods
        
      
        

          2
          
              def action_methods
        
      
        

          
          
                self.class.action_methods
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          
          
              # Returns true if a method for the action is available and
        
      
        

          
          
              # can be dispatched, false otherwise.
        
      
        

          
          
              #
        
      
        

          
          
              # Notice that <tt>action_methods.include?("foo")</tt> may return
        
      
        

          
          
              # false and <tt>available_action?("foo")</tt> returns true because
        
      
        

          
          
              # this method considers actions that are also available
        
      
        

          
          
              # through other means, for example, implicit render ones.
        
      
        

          
          
              #
        
      
        

          
          
              # ==== Parameters
        
      
        

          
          
              # * <tt>action_name</tt> - The name of an action to be tested
        
      
        

          
          
              #
        
      
        

          
          
              # ==== Returns
        
      
        

          
          
              # * <tt>TrueClass</tt>, <tt>FalseClass</tt>
        
      
        

          2
          
              def available_action?(action_name)
        
      
        

          
          
                _find_action_name(action_name).present?
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          
          
              # Returns true if the given controller is capable of rendering
        
      
        

          
          
              # a path. A subclass of +AbstractController::Base+
        
      
        

          
          
              # may return false. An Email controller for example does not
        
      
        

          
          
              # support paths, only full URLs.
        
      
        

          2
          
              def self.supports_path?
        
      
        

          3
          
                true
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          2
          
              private
        
      
        

          
          
          
        
      
        

          
          
                # Returns true if the name can be considered an action because
        
      
        

          
          
                # it has a method defined in the controller.
        
      
        

          
          
                #
        
      
        

          
          
                # ==== Parameters
        
      
        

          
          
                # * <tt>name</tt> - The name of an action to be tested
        
      
        

          
          
                #
        
      
        

          
          
                # ==== Returns
        
      
        

          
          
                # * <tt>TrueClass</tt>, <tt>FalseClass</tt>
        
      
        

          
          
                #
        
      
        

          
          
                # :api: private
        
      
        

          2
          
                def action_method?(name)
        
      
        

          29
          
                  self.class.action_methods.include?(name)
        
      
        

          
          
                end
        
      
        

          
          
          
        
      
        

          
          
                # Call the action. Override this in a subclass to modify the
        
      
        

          
          
                # behavior around processing an action. This, and not #process,
        
      
        

          
          
                # is the intended way to override action dispatching.
        
      
        

          
          
                #
        
      
        

          
          
                # Notice that the first argument is the method to be dispatched
        
      
        

          
          
                # which is *not* necessarily the same as the action name.
        
      
        

          2
          
                def process_action(method_name, *args)
        
      
        

          29
          
                  send_action(method_name, *args)
        
      
        

          
          
                end
        
      
        

          
          
          
        
      
        

          
          
                # Actually call the method associated with the action. Override
        
      
        

          
          
                # this method if you wish to change how action methods are called,
        
      
        

          
          
                # not to add additional behavior around it. For example, you would
        
      
        

          
          
                # override #send_action if you want to inject arguments into the
        
      
        

          
          
                # method.
        
      
        

          2
          
                alias send_action send
        
      
        

          
          
          
        
      
        

          
          
                # If the action name was not found, but a method called "action_missing"
        
      
        

          
          
                # was found, #method_for_action will return "_handle_action_missing".
        
      
        

          
          
                # This method calls #action_missing with the current action name.
        
      
        

          2
          
                def _handle_action_missing(*args)
        
      
        

          
          
                  action_missing(@_action_name, *args)
        
      
        

          
          
                end
        
      
        

          
          
          
        
      
        

          
          
                # Takes an action name and returns the name of the method that will
        
      
        

          
          
                # handle the action.
        
      
        

          
          
                #
        
      
        

          
          
                # It checks if the action name is valid and returns false otherwise.
        
      
        

          
          
                #
        
      
        

          
          
                # See method_for_action for more information.
        
      
        

          
          
                #
        
      
        

          
          
                # ==== Parameters
        
      
        

          
          
                # * <tt>action_name</tt> - An action name to find a method name for
        
      
        

          
          
                #
        
      
        

          
          
                # ==== Returns
        
      
        

          
          
                # * <tt>string</tt> - The name of the method that handles the action
        
      
        

          
          
                # * false           - No valid method name could be found.
        
      
        

          
          
                # Raise AbstractController::ActionNotFound.
        
      
        

          2
          
                def _find_action_name(action_name)
        
      
        

          29
          
                  _valid_action_name?(action_name) && method_for_action(action_name)
        
      
        

          
          
                end
        
      
        

          
          
          
        
      
        

          
          
                # Takes an action name and returns the name of the method that will
        
      
        

          
          
                # handle the action. In normal cases, this method returns the same
        
      
        

          
          
                # name as it receives. By default, if #method_for_action receives
        
      
        

          
          
                # a name that is not an action, it will look for an #action_missing
        
      
        

          
          
                # method and return "_handle_action_missing" if one is found.
        
      
        

          
          
                #
        
      
        

          
          
                # Subclasses may override this method to add additional conditions
        
      
        

          
          
                # that should be considered an action. For instance, an HTTP controller
        
      
        

          
          
                # with a template matching the action name is considered to exist.
        
      
        

          
          
                #
        
      
        

          
          
                # If you override this method to handle additional cases, you may
        
      
        

          
          
                # also provide a method (like _handle_method_missing) to handle
        
      
        

          
          
                # the case.
        
      
        

          
          
                #
        
      
        

          
          
                # If none of these conditions are true, and method_for_action
        
      
        

          
          
                # returns nil, an AbstractController::ActionNotFound exception will be raised.
        
      
        

          
          
                #
        
      
        

          
          
                # ==== Parameters
        
      
        

          
          
                # * <tt>action_name</tt> - An action name to find a method name for
        
      
        

          
          
                #
        
      
        

          
          
                # ==== Returns
        
      
        

          
          
                # * <tt>string</tt> - The name of the method that handles the action
        
      
        

          
          
                # * <tt>nil</tt>    - No method name could be found.
        
      
        

          2
          
                def method_for_action(action_name)
        
      
        

          29
          
                  if action_method?(action_name)
        
      
        

          29
          
                    action_name
        
      
        

          
          
                  elsif respond_to?(:action_missing, true)
        
      
        

          
          
                    "_handle_action_missing"
        
      
        

          
          
                  end
        
      
        

          
          
                end
        
      
        

          
          
          
        
      
        

          
          
                # Checks if the action name is valid and returns false otherwise.
        
      
        

          2
          
                def _valid_action_name?(action_name)
        
      
        

          29
          
                  !action_name.to_s.include? File::SEPARATOR
        
      
        

          
          
                end
        
      
        

          
          
            end
        
      
        

          
          
          end
        
      
    
  

    

      
        

          2
          
          module AbstractController
        
      
        

          2
          
            module Callbacks
        
      
        

          2
          
              extend ActiveSupport::Concern
        
      
        

          
          
          
        
      
        

          
          
              # Uses ActiveSupport::Callbacks as the base functionality. For
        
      
        

          
          
              # more details on the whole callback system, read the documentation
        
      
        

          
          
              # for ActiveSupport::Callbacks.
        
      
        

          2
          
              include ActiveSupport::Callbacks
        
      
        

          
          
          
        
      
        

          2
          
              included do
        
      
        

          4
          
                define_callbacks :process_action,
        
      
        

          135
          
                                 terminator: ->(controller,_) { controller.response_body },
        
      
        

          
          
                                 skip_after_callbacks_if_terminated: true
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          
          
              # Override AbstractController::Base's process_action to run the
        
      
        

          
          
              # process_action callbacks around the normal behavior.
        
      
        

          2
          
              def process_action(*args)
        
      
        

          29
          
                run_callbacks(:process_action) do
        
      
        

          29
          
                  super
        
      
        

          
          
                end
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          2
          
              module ClassMethods
        
      
        

          
          
                # If :only or :except are used, convert the options into the
        
      
        

          
          
                # :unless and :if options of ActiveSupport::Callbacks.
        
      
        

          
          
                # The basic idea is that :only => :index gets converted to
        
      
        

          
          
                # :if => proc {|c| c.action_name == "index" }.
        
      
        

          
          
                #
        
      
        

          
          
                # ==== Options
        
      
        

          
          
                # * <tt>only</tt>   - The callback should be run only for this action
        
      
        

          
          
                # * <tt>except</tt>  - The callback should be run for all actions except this action
        
      
        

          2
          
                def _normalize_callback_options(options)
        
      
        

          23
          
                  _normalize_callback_option(options, :only, :if)
        
      
        

          23
          
                  _normalize_callback_option(options, :except, :unless)
        
      
        

          
          
                end
        
      
        

          
          
          
        
      
        

          2
          
                def _normalize_callback_option(options, from, to) # :nodoc:
        
      
        

          46
          
                  if from = options[from]
        
      
        

          50
          
                    from = Array(from).map {|o| "action_name == '#{o}'"}.join(" || ")
        
      
        

          12
          
                    options[to] = Array(options[to]).unshift(from)
        
      
        

          
          
                  end
        
      
        

          
          
                end
        
      
        

          
          
          
        
      
        

          
          
                # Skip before, after, and around action callbacks matching any of the names.
        
      
        

          
          
                #
        
      
        

          
          
                # ==== Parameters
        
      
        

          
          
                # * <tt>names</tt> - A list of valid names that could be used for
        
      
        

          
          
                #   callbacks. Note that skipping uses Ruby equality, so it's
        
      
        

          
          
                #   impossible to skip a callback defined using an anonymous proc
        
      
        

          
          
                #   using #skip_action_callback
        
      
        

          2
          
                def skip_action_callback(*names)
        
      
        

          
          
                  skip_before_action(*names)
        
      
        

          
          
                  skip_after_action(*names)
        
      
        

          
          
                  skip_around_action(*names)
        
      
        

          
          
                end
        
      
        

          2
          
                alias_method :skip_filter, :skip_action_callback
        
      
        

          
          
          
        
      
        

          
          
                # Take callback names and an optional callback proc, normalize them,
        
      
        

          
          
                # then call the block with each callback. This allows us to abstract
        
      
        

          
          
                # the normalization across several methods that use it.
        
      
        

          
          
                #
        
      
        

          
          
                # ==== Parameters
        
      
        

          
          
                # * <tt>callbacks</tt> - An array of callbacks, with an optional
        
      
        

          
          
                #   options hash as the last parameter.
        
      
        

          
          
                # * <tt>block</tt>    - A proc that should be added to the callbacks.
        
      
        

          
          
                #
        
      
        

          
          
                # ==== Block Parameters
        
      
        

          
          
                # * <tt>name</tt>     - The callback to be added
        
      
        

          
          
                # * <tt>options</tt>  - A hash of options to be used when adding the callback
        
      
        

          2
          
                def _insert_callbacks(callbacks, block = nil)
        
      
        

          23
          
                  options = callbacks.extract_options!
        
      
        

          23
          
                  _normalize_callback_options(options)
        
      
        

          23
          
                  callbacks.push(block) if block
        
      
        

          23
          
                  callbacks.each do |callback|
        
      
        

          25
          
                    yield callback, options
        
      
        

          
          
                  end
        
      
        

          
          
                end
        
      
        

          
          
          
        
      
        

          
          
                ##
        
      
        

          
          
                # :method: before_action
        
      
        

          
          
                #
        
      
        

          
          
                # :call-seq: before_action(names, block)
        
      
        

          
          
                #
        
      
        

          
          
                # Append a callback before actions. See _insert_callbacks for parameter details.
        
      
        

          
          
          
        
      
        

          
          
                ##
        
      
        

          
          
                # :method: prepend_before_action
        
      
        

          
          
                #
        
      
        

          
          
                # :call-seq: prepend_before_action(names, block)
        
      
        

          
          
                #
        
      
        

          
          
                # Prepend a callback before actions. See _insert_callbacks for parameter details.
        
      
        

          
          
          
        
      
        

          
          
                ##
        
      
        

          
          
                # :method: skip_before_action
        
      
        

          
          
                #
        
      
        

          
          
                # :call-seq: skip_before_action(names)
        
      
        

          
          
                #
        
      
        

          
          
                # Skip a callback before actions. See _insert_callbacks for parameter details.
        
      
        

          
          
          
        
      
        

          
          
                ##
        
      
        

          
          
                # :method: append_before_action
        
      
        

          
          
                #
        
      
        

          
          
                # :call-seq: append_before_action(names, block)
        
      
        

          
          
                #
        
      
        

          
          
                # Append a callback before actions. See _insert_callbacks for parameter details.
        
      
        

          
          
          
        
      
        

          
          
                ##
        
      
        

          
          
                # :method: after_action
        
      
        

          
          
                #
        
      
        

          
          
                # :call-seq: after_action(names, block)
        
      
        

          
          
                #
        
      
        

          
          
                # Append a callback after actions. See _insert_callbacks for parameter details.
        
      
        

          
          
          
        
      
        

          
          
                ##
        
      
        

          
          
                # :method: prepend_after_action
        
      
        

          
          
                #
        
      
        

          
          
                # :call-seq: prepend_after_action(names, block)
        
      
        

          
          
                #
        
      
        

          
          
                # Prepend a callback after actions. See _insert_callbacks for parameter details.
        
      
        

          
          
          
        
      
        

          
          
                ##
        
      
        

          
          
                # :method: skip_after_action
        
      
        

          
          
                #
        
      
        

          
          
                # :call-seq: skip_after_action(names)
        
      
        

          
          
                #
        
      
        

          
          
                # Skip a callback after actions. See _insert_callbacks for parameter details.
        
      
        

          
          
          
        
      
        

          
          
                ##
        
      
        

          
          
                # :method: append_after_action
        
      
        

          
          
                #
        
      
        

          
          
                # :call-seq: append_after_action(names, block)
        
      
        

          
          
                #
        
      
        

          
          
                # Append a callback after actions. See _insert_callbacks for parameter details.
        
      
        

          
          
          
        
      
        

          
          
                ##
        
      
        

          
          
                # :method: around_action
        
      
        

          
          
                #
        
      
        

          
          
                # :call-seq: around_action(names, block)
        
      
        

          
          
                #
        
      
        

          
          
                # Append a callback around actions. See _insert_callbacks for parameter details.
        
      
        

          
          
          
        
      
        

          
          
                ##
        
      
        

          
          
                # :method: prepend_around_action
        
      
        

          
          
                #
        
      
        

          
          
                # :call-seq: prepend_around_action(names, block)
        
      
        

          
          
                #
        
      
        

          
          
                # Prepend a callback around actions. See _insert_callbacks for parameter details.
        
      
        

          
          
          
        
      
        

          
          
                ##
        
      
        

          
          
                # :method: skip_around_action
        
      
        

          
          
                #
        
      
        

          
          
                # :call-seq: skip_around_action(names)
        
      
        

          
          
                #
        
      
        

          
          
                # Skip a callback around actions. See _insert_callbacks for parameter details.
        
      
        

          
          
          
        
      
        

          
          
                ##
        
      
        

          
          
                # :method: append_around_action
        
      
        

          
          
                #
        
      
        

          
          
                # :call-seq: append_around_action(names, block)
        
      
        

          
          
                #
        
      
        

          
          
                # Append a callback around actions. See _insert_callbacks for parameter details.
        
      
        

          
          
          
        
      
        

          
          
                # set up before_action, prepend_before_action, skip_before_action, etc.
        
      
        

          
          
                # for each of before, after, and around.
        
      
        

          2
          
                [:before, :after, :around].each do |callback|
        
      
        

          6
          
                  define_method "#{callback}_action" do |*names, &blk|
        
      
        

          20
          
                    _insert_callbacks(names, blk) do |name, options|
        
      
        

          22
          
                      set_callback(:process_action, callback, name, options)
        
      
        

          
          
                    end
        
      
        

          
          
                  end
        
      
        

          6
          
                  alias_method :"#{callback}_filter", :"#{callback}_action"
        
      
        

          
          
          
        
      
        

          6
          
                  define_method "prepend_#{callback}_action" do |*names, &blk|
        
      
        

          3
          
                    _insert_callbacks(names, blk) do |name, options|
        
      
        

          3
          
                      set_callback(:process_action, callback, name, options.merge(:prepend => true))
        
      
        

          
          
                    end
        
      
        

          
          
                  end
        
      
        

          6
          
                  alias_method :"prepend_#{callback}_filter", :"prepend_#{callback}_action"
        
      
        

          
          
          
        
      
        

          
          
                  # Skip a before, after or around callback. See _insert_callbacks
        
      
        

          
          
                  # for details on the allowed parameters.
        
      
        

          6
          
                  define_method "skip_#{callback}_action" do |*names|
        
      
        

          
          
                    _insert_callbacks(names) do |name, options|
        
      
        

          
          
                      skip_callback(:process_action, callback, name, options)
        
      
        

          
          
                    end
        
      
        

          
          
                  end
        
      
        

          6
          
                  alias_method :"skip_#{callback}_filter", :"skip_#{callback}_action"
        
      
        

          
          
          
        
      
        

          
          
                  # *_action is the same as append_*_action
        
      
        

          6
          
                  alias_method :"append_#{callback}_action", :"#{callback}_action"
        
      
        

          6
          
                  alias_method :"append_#{callback}_filter", :"#{callback}_action"
        
      
        

          
          
                end
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          end